home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 19 / CU Amiga Magazine's Super CD-ROM 19 (1998)(EMAP Images)(GB)[!][issue 1998-02].iso / CUCD / Programming / LEDA / source / src / arith / irad.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-11-16  |  3.4 KB  |  129 lines
  1. /*******************************************************************************
  2. +
  3. +  LEDA  3.1c
  4. +
  5. +
  6. +  irad.c
  7. +
  8. +
  9. +  Copyright (c) 1994  by  Max-Planck-Institut fuer Informatik
  10. +  Im Stadtwald, 6600 Saarbruecken, FRG     
  11. +  All rights reserved.
  12. + 
  13. *******************************************************************************/
  14.  
  15.  
  16. #include <LEDA/impl/iint.h>
  17. #include <LEDA/impl/iloc.h>
  18.  
  19. EXTERN_FUNCTION(void radaddto, (PLACE *a, PLACE *b, PLACE *carry));
  20.         /* a=a+b+carry, Uebertrag in carry */
  21. EXTERN_FUNCTION(void radsubto, (PLACE *a, PLACE *b, PLACE *carry));
  22.         /* a=a-b-carry, Uebertrag in carry */
  23. EXTERN_FUNCTION(void radmul, (PLACE *a, PLACE *b, PLACE *m, PLACE *carry));
  24.         /* m=m+a*b+carry, Uebertrag in carry */
  25. EXTERN_FUNCTION(void raddiv, (PLACE *h, PLACE *l, PLACE *n, PLACE *q));
  26.         /* h*RADIX+l / n ergibt Quotient q und Rest h */
  27.  
  28.  
  29. #ifndef ATARI
  30. void radaddto(a, b, carry)
  31.         PLACE *a, *b, *carry;
  32.         /* Addiere *b und *carry zu *a, Uebertrag in *carry */
  33. {       register DOUBLEPLACE accu = 0;
  34.         accu = *a;
  35.         accu += *b;
  36.         accu += *carry;
  37.         *a = accu;
  38.         /* *carry = accu >> LOGPLACE; */
  39.         *carry = 0;
  40. }
  41. #endif
  42.  
  43. void radsubto(a, b, carry)
  44.         PLACE *a, *b, *carry;
  45.         /* Subtrahiere *b und *carry von *a, Uebertrag in *carry
  46.               und zwar 0 oder 1                 */
  47. {       register DOUBLEPLACE accu = 0;
  48.         accu = *a;
  49.         accu -= *b;
  50.         accu -= *carry;
  51.         *a = accu;
  52.         /* accu >>= LOGPLACE; */
  53.         accu  &= 1;
  54.         *carry = accu;
  55. }
  56.  
  57. #ifndef __PARC__
  58. #ifndef ATARI
  59. void radmul(a, b, m, carry)
  60.         PLACE *a, *b, *m, *carry;
  61.         /* Multipliziere und addiere:
  62.               accu   = *a * *b + *m + *carry;
  63.               *m     = accu % RADIX;
  64.               *carry = accu / RADIX;    */
  65. {       register DOUBLEPLACE accu = 0;
  66.         accu = *a;
  67.         accu *= *b;
  68.         accu += *m;
  69.         accu += *carry;
  70.         *m = accu;
  71.         /* *carry = accu >> LOGPLACE; */
  72.         *carry = 0;
  73. }
  74. #endif
  75. #endif
  76.  
  77. #ifndef __PARC__
  78. #ifndef ATARI
  79. void raddiv(h, l, n, q)
  80.         PLACE *h, *l, *n, *q;
  81.         /* Division mit Rest
  82.               (*h)*RADIX + (*l) == (*n)*(*q) + (*r)
  83.               Voraussetzung:     *h < *n                */
  84. {       register DOUBLEPLACE accu = 0;
  85.         accu = *h; 
  86.         /* accu <<= LOGPLACE; */
  87.         accu += *l;
  88.         *q = accu / *n;
  89.         *h = accu % *n;
  90. }
  91. #endif
  92. #endif
  93.  
  94. /************************************************************/
  95.  
  96. #ifdef USE_PLACE_RAD
  97.  
  98. void radaddto(a, b, carry)
  99.         PLACE *a, *b, *carry;
  100.         /* Addiere *b und *carry zu *a, Uebertrag in *carry */
  101. {       *carry=PLACEadd(*a, *b, *carry, a);
  102. }
  103.  
  104. void radsubto(a, b, carry)
  105.         PLACE *a, *b, *carry;
  106.         /* Subtrahiere *b und *carry von *a, Uebertrag in *carry
  107.               und zwar 0 oder 1                 */
  108. {       *carry=PLACEsub(*a, *b, *carry, a);
  109. }
  110.  
  111. void radmul(a, b, m, carry)
  112.         PLACE *a, *b, *m, *carry;
  113.         /* Multipliziere und addiere:
  114.               accu   = *a * *b + *m + *carry;
  115.               *m     = accu % RADIX;
  116.               *carry = accu / RADIX;    */
  117. {       *carry=PLACEmuladd(*a, *b, *carry, m);
  118. }
  119.  
  120. void raddiv(h, l, n, q)
  121.         PLACE *h, *l, *n, *q;
  122.         /* Division mit Rest
  123.               (*h)*RADIX + (*l) == (*n)*(*q) + (*r)
  124.               Voraussetzung:     *h < *n                */
  125. {       *h=PLACEdiv(*h, *l, *n, q);
  126. }
  127.  
  128. #endif
  129.